/*
 * XML Type:  XForm
 * Namespace: http://www.seedwill.com/xul/form/
 * Java type: com.seedwill.xul.form.XForm
 *
 * Automatically generated - do not modify.
 */
package com.seedwill.xul.form.impl;
/**
 * An XML XForm(@http://www.seedwill.com/xul/form/).
 *
 * This is a complex type.
 */
public class XFormImpl extends com.seedwill.xul.widget.impl.XControlImpl implements com.seedwill.xul.form.XForm
{
    private static final long serialVersionUID = 1L;
    
    public XFormImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName LAYOUT$0 = 
        new javax.xml.namespace.QName("", "layout");
    private static final javax.xml.namespace.QName DBSOURCE$2 = 
        new javax.xml.namespace.QName("", "dbSource");
    private static final javax.xml.namespace.QName DBSCHEMASOURCE$4 = 
        new javax.xml.namespace.QName("", "dbSchemaSource");
    private static final javax.xml.namespace.QName TYPE$6 = 
        new javax.xml.namespace.QName("", "type");
    private static final javax.xml.namespace.QName MODE$8 = 
        new javax.xml.namespace.QName("", "mode");
    private static final javax.xml.namespace.QName TITLE$10 = 
        new javax.xml.namespace.QName("", "title");
    private static final javax.xml.namespace.QName AREAS$12 = 
        new javax.xml.namespace.QName("", "areas");
    private static final javax.xml.namespace.QName INTERACTSTRATEGY$14 = 
        new javax.xml.namespace.QName("", "interactStrategy");
    private static final javax.xml.namespace.QName CATEGORY$16 = 
        new javax.xml.namespace.QName("", "category");
    private static final javax.xml.namespace.QName SCHEMAS$18 = 
        new javax.xml.namespace.QName("", "schemas");
    private static final javax.xml.namespace.QName ADAPTORS$20 = 
        new javax.xml.namespace.QName("", "adaptors");
    private static final javax.xml.namespace.QName SCHEMAOUT$22 = 
        new javax.xml.namespace.QName("", "schemaOut");
    private static final javax.xml.namespace.QName SCHEMAOUTTYPE$24 = 
        new javax.xml.namespace.QName("", "schemaOutType");
    private static final javax.xml.namespace.QName ADAPTOROUT$26 = 
        new javax.xml.namespace.QName("", "adaptorOut");
    private static final javax.xml.namespace.QName ADAPTOROUTTYPE$28 = 
        new javax.xml.namespace.QName("", "adaptorOutType");
    private static final javax.xml.namespace.QName SCHEMAIN$30 = 
        new javax.xml.namespace.QName("", "schemaIn");
    private static final javax.xml.namespace.QName SCHEMAINTYPE$32 = 
        new javax.xml.namespace.QName("", "schemaInType");
    private static final javax.xml.namespace.QName ADAPTORIN$34 = 
        new javax.xml.namespace.QName("", "adaptorIn");
    private static final javax.xml.namespace.QName ADAPTORINTYPE$36 = 
        new javax.xml.namespace.QName("", "adaptorInType");
    private static final javax.xml.namespace.QName KEYSCHEMA$38 = 
        new javax.xml.namespace.QName("", "keySchema");
    private static final javax.xml.namespace.QName COMMAND$40 = 
        new javax.xml.namespace.QName("", "command");
    private static final javax.xml.namespace.QName SCHEMAID$42 = 
        new javax.xml.namespace.QName("", "schemaId");
    
    
    /**
     * Gets first "layout" element
     */
    public com.seedwill.xul.core.XTableLayout getLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().find_element_user(LAYOUT$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has at least one "layout" element
     */
    public boolean isSetLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LAYOUT$0) != 0;
        }
    }
    
    /**
     * Gets array of all "layout" elements
     */
    public com.seedwill.xul.core.XTableLayout[] getLayoutArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(LAYOUT$0, targetList);
            com.seedwill.xul.core.XTableLayout[] result = new com.seedwill.xul.core.XTableLayout[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "layout" element
     */
    public com.seedwill.xul.core.XTableLayout getLayoutArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().find_element_user(LAYOUT$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "layout" element
     */
    public int sizeOfLayoutArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LAYOUT$0);
        }
    }
    
    /**
     * Sets first "layout" element
     */
    public void setLayout(com.seedwill.xul.core.XTableLayout layout)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().find_element_user(LAYOUT$0, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XTableLayout)get_store().add_element_user(LAYOUT$0);
            }
            target.set(layout);
        }
    }
    
    /**
     * Removes first "layout" element
     */
    public void unsetLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LAYOUT$0, 0);
        }
    }
    
    /**
     * Sets array of all "layout" element
     */
    public void setLayoutArray(com.seedwill.xul.core.XTableLayout[] layoutArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(layoutArray, LAYOUT$0);
        }
    }
    
    /**
     * Sets ith "layout" element
     */
    public void setLayoutArray(int i, com.seedwill.xul.core.XTableLayout layout)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().find_element_user(LAYOUT$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(layout);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "layout" element
     */
    public com.seedwill.xul.core.XTableLayout insertNewLayout(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().insert_element_user(LAYOUT$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "layout" element
     */
    public com.seedwill.xul.core.XTableLayout addNewLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().add_element_user(LAYOUT$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "layout" element
     */
    public void removeLayout(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LAYOUT$0, i);
        }
    }
    
    /**
     * Gets first "dbSource" element
     */
    public com.seedwill.xul.core.XDBSource getDbSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSource target = null;
            target = (com.seedwill.xul.core.XDBSource)get_store().find_element_user(DBSOURCE$2, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has at least one "dbSource" element
     */
    public boolean isSetDbSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DBSOURCE$2) != 0;
        }
    }
    
    /**
     * Gets array of all "dbSource" elements
     */
    public com.seedwill.xul.core.XDBSource[] getDbSourceArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(DBSOURCE$2, targetList);
            com.seedwill.xul.core.XDBSource[] result = new com.seedwill.xul.core.XDBSource[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "dbSource" element
     */
    public com.seedwill.xul.core.XDBSource getDbSourceArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSource target = null;
            target = (com.seedwill.xul.core.XDBSource)get_store().find_element_user(DBSOURCE$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "dbSource" element
     */
    public int sizeOfDbSourceArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DBSOURCE$2);
        }
    }
    
    /**
     * Sets first "dbSource" element
     */
    public void setDbSource(com.seedwill.xul.core.XDBSource dbSource)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSource target = null;
            target = (com.seedwill.xul.core.XDBSource)get_store().find_element_user(DBSOURCE$2, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XDBSource)get_store().add_element_user(DBSOURCE$2);
            }
            target.set(dbSource);
        }
    }
    
    /**
     * Removes first "dbSource" element
     */
    public void unsetDbSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DBSOURCE$2, 0);
        }
    }
    
    /**
     * Sets array of all "dbSource" element
     */
    public void setDbSourceArray(com.seedwill.xul.core.XDBSource[] dbSourceArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(dbSourceArray, DBSOURCE$2);
        }
    }
    
    /**
     * Sets ith "dbSource" element
     */
    public void setDbSourceArray(int i, com.seedwill.xul.core.XDBSource dbSource)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSource target = null;
            target = (com.seedwill.xul.core.XDBSource)get_store().find_element_user(DBSOURCE$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(dbSource);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "dbSource" element
     */
    public com.seedwill.xul.core.XDBSource insertNewDbSource(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSource target = null;
            target = (com.seedwill.xul.core.XDBSource)get_store().insert_element_user(DBSOURCE$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "dbSource" element
     */
    public com.seedwill.xul.core.XDBSource addNewDbSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSource target = null;
            target = (com.seedwill.xul.core.XDBSource)get_store().add_element_user(DBSOURCE$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "dbSource" element
     */
    public void removeDbSource(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DBSOURCE$2, i);
        }
    }
    
    /**
     * Gets first "dbSchemaSource" element
     */
    public com.seedwill.xul.core.XDBSchemaSource getDbSchemaSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSchemaSource target = null;
            target = (com.seedwill.xul.core.XDBSchemaSource)get_store().find_element_user(DBSCHEMASOURCE$4, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has at least one "dbSchemaSource" element
     */
    public boolean isSetDbSchemaSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DBSCHEMASOURCE$4) != 0;
        }
    }
    
    /**
     * Gets array of all "dbSchemaSource" elements
     */
    public com.seedwill.xul.core.XDBSchemaSource[] getDbSchemaSourceArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(DBSCHEMASOURCE$4, targetList);
            com.seedwill.xul.core.XDBSchemaSource[] result = new com.seedwill.xul.core.XDBSchemaSource[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "dbSchemaSource" element
     */
    public com.seedwill.xul.core.XDBSchemaSource getDbSchemaSourceArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSchemaSource target = null;
            target = (com.seedwill.xul.core.XDBSchemaSource)get_store().find_element_user(DBSCHEMASOURCE$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "dbSchemaSource" element
     */
    public int sizeOfDbSchemaSourceArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DBSCHEMASOURCE$4);
        }
    }
    
    /**
     * Sets first "dbSchemaSource" element
     */
    public void setDbSchemaSource(com.seedwill.xul.core.XDBSchemaSource dbSchemaSource)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSchemaSource target = null;
            target = (com.seedwill.xul.core.XDBSchemaSource)get_store().find_element_user(DBSCHEMASOURCE$4, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XDBSchemaSource)get_store().add_element_user(DBSCHEMASOURCE$4);
            }
            target.set(dbSchemaSource);
        }
    }
    
    /**
     * Removes first "dbSchemaSource" element
     */
    public void unsetDbSchemaSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DBSCHEMASOURCE$4, 0);
        }
    }
    
    /**
     * Sets array of all "dbSchemaSource" element
     */
    public void setDbSchemaSourceArray(com.seedwill.xul.core.XDBSchemaSource[] dbSchemaSourceArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(dbSchemaSourceArray, DBSCHEMASOURCE$4);
        }
    }
    
    /**
     * Sets ith "dbSchemaSource" element
     */
    public void setDbSchemaSourceArray(int i, com.seedwill.xul.core.XDBSchemaSource dbSchemaSource)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSchemaSource target = null;
            target = (com.seedwill.xul.core.XDBSchemaSource)get_store().find_element_user(DBSCHEMASOURCE$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(dbSchemaSource);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "dbSchemaSource" element
     */
    public com.seedwill.xul.core.XDBSchemaSource insertNewDbSchemaSource(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSchemaSource target = null;
            target = (com.seedwill.xul.core.XDBSchemaSource)get_store().insert_element_user(DBSCHEMASOURCE$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "dbSchemaSource" element
     */
    public com.seedwill.xul.core.XDBSchemaSource addNewDbSchemaSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XDBSchemaSource target = null;
            target = (com.seedwill.xul.core.XDBSchemaSource)get_store().add_element_user(DBSCHEMASOURCE$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "dbSchemaSource" element
     */
    public void removeDbSchemaSource(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DBSCHEMASOURCE$4, i);
        }
    }
    
    /**
     * Gets the "type" element
     */
    public java.lang.String getType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TYPE$6, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "type" element
     */
    public org.apache.xmlbeans.XmlString xgetType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(TYPE$6, 0);
            return target;
        }
    }
    
    /**
     * Sets the "type" element
     */
    public void setType(java.lang.String type)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TYPE$6, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(TYPE$6);
            }
            target.setStringValue(type);
        }
    }
    
    /**
     * Sets (as xml) the "type" element
     */
    public void xsetType(org.apache.xmlbeans.XmlString type)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(TYPE$6, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(TYPE$6);
            }
            target.set(type);
        }
    }
    
    /**
     * Gets the "mode" element
     */
    public com.seedwill.xul.core.XFormMode.Enum getMode()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(MODE$8, 0);
            if (target == null)
            {
                return null;
            }
            return (com.seedwill.xul.core.XFormMode.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "mode" element
     */
    public com.seedwill.xul.core.XFormMode xgetMode()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XFormMode target = null;
            target = (com.seedwill.xul.core.XFormMode)get_store().find_element_user(MODE$8, 0);
            return target;
        }
    }
    
    /**
     * Sets the "mode" element
     */
    public void setMode(com.seedwill.xul.core.XFormMode.Enum mode)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(MODE$8, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(MODE$8);
            }
            target.setEnumValue(mode);
        }
    }
    
    /**
     * Sets (as xml) the "mode" element
     */
    public void xsetMode(com.seedwill.xul.core.XFormMode mode)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XFormMode target = null;
            target = (com.seedwill.xul.core.XFormMode)get_store().find_element_user(MODE$8, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XFormMode)get_store().add_element_user(MODE$8);
            }
            target.set(mode);
        }
    }
    
    /**
     * Gets the "title" element
     */
    public java.lang.String getTitle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TITLE$10, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "title" element
     */
    public org.apache.xmlbeans.XmlString xgetTitle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(TITLE$10, 0);
            return target;
        }
    }
    
    /**
     * True if has "title" element
     */
    public boolean isSetTitle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TITLE$10) != 0;
        }
    }
    
    /**
     * Sets the "title" element
     */
    public void setTitle(java.lang.String title)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TITLE$10, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(TITLE$10);
            }
            target.setStringValue(title);
        }
    }
    
    /**
     * Sets (as xml) the "title" element
     */
    public void xsetTitle(org.apache.xmlbeans.XmlString title)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(TITLE$10, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(TITLE$10);
            }
            target.set(title);
        }
    }
    
    /**
     * Unsets the "title" element
     */
    public void unsetTitle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TITLE$10, 0);
        }
    }
    
    /**
     * Gets array of all "areas" elements
     */
    public com.seedwill.xul.widget.XArea[] getAreasArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(AREAS$12, targetList);
            com.seedwill.xul.widget.XArea[] result = new com.seedwill.xul.widget.XArea[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "areas" element
     */
    public com.seedwill.xul.widget.XArea getAreasArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().find_element_user(AREAS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "areas" element
     */
    public int sizeOfAreasArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(AREAS$12);
        }
    }
    
    /**
     * Sets array of all "areas" element
     */
    public void setAreasArray(com.seedwill.xul.widget.XArea[] areasArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(areasArray, AREAS$12);
        }
    }
    
    /**
     * Sets ith "areas" element
     */
    public void setAreasArray(int i, com.seedwill.xul.widget.XArea areas)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().find_element_user(AREAS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(areas);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "areas" element
     */
    public com.seedwill.xul.widget.XArea insertNewAreas(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().insert_element_user(AREAS$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "areas" element
     */
    public com.seedwill.xul.widget.XArea addNewAreas()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().add_element_user(AREAS$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "areas" element
     */
    public void removeAreas(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(AREAS$12, i);
        }
    }
    
    /**
     * Gets the "interactStrategy" element
     */
    public com.seedwill.xul.core.XInteractStrategy getInteractStrategy()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XInteractStrategy target = null;
            target = (com.seedwill.xul.core.XInteractStrategy)get_store().find_element_user(INTERACTSTRATEGY$14, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "interactStrategy" element
     */
    public boolean isSetInteractStrategy()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTERACTSTRATEGY$14) != 0;
        }
    }
    
    /**
     * Sets the "interactStrategy" element
     */
    public void setInteractStrategy(com.seedwill.xul.core.XInteractStrategy interactStrategy)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XInteractStrategy target = null;
            target = (com.seedwill.xul.core.XInteractStrategy)get_store().find_element_user(INTERACTSTRATEGY$14, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XInteractStrategy)get_store().add_element_user(INTERACTSTRATEGY$14);
            }
            target.set(interactStrategy);
        }
    }
    
    /**
     * Appends and returns a new empty "interactStrategy" element
     */
    public com.seedwill.xul.core.XInteractStrategy addNewInteractStrategy()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XInteractStrategy target = null;
            target = (com.seedwill.xul.core.XInteractStrategy)get_store().add_element_user(INTERACTSTRATEGY$14);
            return target;
        }
    }
    
    /**
     * Unsets the "interactStrategy" element
     */
    public void unsetInteractStrategy()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTERACTSTRATEGY$14, 0);
        }
    }
    
    /**
     * Gets the "category" element
     */
    public com.seedwill.xul.core.XFormCategory.Enum getCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(CATEGORY$16, 0);
            if (target == null)
            {
                return null;
            }
            return (com.seedwill.xul.core.XFormCategory.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "category" element
     */
    public com.seedwill.xul.core.XFormCategory xgetCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XFormCategory target = null;
            target = (com.seedwill.xul.core.XFormCategory)get_store().find_element_user(CATEGORY$16, 0);
            return target;
        }
    }
    
    /**
     * True if has "category" element
     */
    public boolean isSetCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CATEGORY$16) != 0;
        }
    }
    
    /**
     * Sets the "category" element
     */
    public void setCategory(com.seedwill.xul.core.XFormCategory.Enum category)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(CATEGORY$16, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(CATEGORY$16);
            }
            target.setEnumValue(category);
        }
    }
    
    /**
     * Sets (as xml) the "category" element
     */
    public void xsetCategory(com.seedwill.xul.core.XFormCategory category)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XFormCategory target = null;
            target = (com.seedwill.xul.core.XFormCategory)get_store().find_element_user(CATEGORY$16, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XFormCategory)get_store().add_element_user(CATEGORY$16);
            }
            target.set(category);
        }
    }
    
    /**
     * Unsets the "category" element
     */
    public void unsetCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CATEGORY$16, 0);
        }
    }
    
    /**
     * Gets array of all "schemas" elements
     */
    public com.seedwill.xul.core.XSchema[] getSchemasArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SCHEMAS$18, targetList);
            com.seedwill.xul.core.XSchema[] result = new com.seedwill.xul.core.XSchema[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "schemas" element
     */
    public com.seedwill.xul.core.XSchema getSchemasArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XSchema target = null;
            target = (com.seedwill.xul.core.XSchema)get_store().find_element_user(SCHEMAS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "schemas" element
     */
    public int sizeOfSchemasArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAS$18);
        }
    }
    
    /**
     * Sets array of all "schemas" element
     */
    public void setSchemasArray(com.seedwill.xul.core.XSchema[] schemasArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(schemasArray, SCHEMAS$18);
        }
    }
    
    /**
     * Sets ith "schemas" element
     */
    public void setSchemasArray(int i, com.seedwill.xul.core.XSchema schemas)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XSchema target = null;
            target = (com.seedwill.xul.core.XSchema)get_store().find_element_user(SCHEMAS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(schemas);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "schemas" element
     */
    public com.seedwill.xul.core.XSchema insertNewSchemas(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XSchema target = null;
            target = (com.seedwill.xul.core.XSchema)get_store().insert_element_user(SCHEMAS$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "schemas" element
     */
    public com.seedwill.xul.core.XSchema addNewSchemas()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XSchema target = null;
            target = (com.seedwill.xul.core.XSchema)get_store().add_element_user(SCHEMAS$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "schemas" element
     */
    public void removeSchemas(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAS$18, i);
        }
    }
    
    /**
     * Gets array of all "adaptors" elements
     */
    public com.seedwill.xul.core.XAdaptor[] getAdaptorsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(ADAPTORS$20, targetList);
            com.seedwill.xul.core.XAdaptor[] result = new com.seedwill.xul.core.XAdaptor[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "adaptors" element
     */
    public com.seedwill.xul.core.XAdaptor getAdaptorsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XAdaptor target = null;
            target = (com.seedwill.xul.core.XAdaptor)get_store().find_element_user(ADAPTORS$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "adaptors" element
     */
    public int sizeOfAdaptorsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTORS$20);
        }
    }
    
    /**
     * Sets array of all "adaptors" element
     */
    public void setAdaptorsArray(com.seedwill.xul.core.XAdaptor[] adaptorsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(adaptorsArray, ADAPTORS$20);
        }
    }
    
    /**
     * Sets ith "adaptors" element
     */
    public void setAdaptorsArray(int i, com.seedwill.xul.core.XAdaptor adaptors)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XAdaptor target = null;
            target = (com.seedwill.xul.core.XAdaptor)get_store().find_element_user(ADAPTORS$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(adaptors);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "adaptors" element
     */
    public com.seedwill.xul.core.XAdaptor insertNewAdaptors(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XAdaptor target = null;
            target = (com.seedwill.xul.core.XAdaptor)get_store().insert_element_user(ADAPTORS$20, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "adaptors" element
     */
    public com.seedwill.xul.core.XAdaptor addNewAdaptors()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XAdaptor target = null;
            target = (com.seedwill.xul.core.XAdaptor)get_store().add_element_user(ADAPTORS$20);
            return target;
        }
    }
    
    /**
     * Removes the ith "adaptors" element
     */
    public void removeAdaptors(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTORS$20, i);
        }
    }
    
    /**
     * Gets the "schemaOut" element
     */
    public java.lang.String getSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUT$22, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaOut" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUT$22, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaOut" element
     */
    public boolean isSetSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAOUT$22) != 0;
        }
    }
    
    /**
     * Sets the "schemaOut" element
     */
    public void setSchemaOut(java.lang.String schemaOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUT$22, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAOUT$22);
            }
            target.setStringValue(schemaOut);
        }
    }
    
    /**
     * Sets (as xml) the "schemaOut" element
     */
    public void xsetSchemaOut(org.apache.xmlbeans.XmlString schemaOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUT$22, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAOUT$22);
            }
            target.set(schemaOut);
        }
    }
    
    /**
     * Unsets the "schemaOut" element
     */
    public void unsetSchemaOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAOUT$22, 0);
        }
    }
    
    /**
     * Gets the "schemaOutType" element
     */
    public java.lang.String getSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUTTYPE$24, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaOutType" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUTTYPE$24, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaOutType" element
     */
    public boolean isSetSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAOUTTYPE$24) != 0;
        }
    }
    
    /**
     * Sets the "schemaOutType" element
     */
    public void setSchemaOutType(java.lang.String schemaOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAOUTTYPE$24, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAOUTTYPE$24);
            }
            target.setStringValue(schemaOutType);
        }
    }
    
    /**
     * Sets (as xml) the "schemaOutType" element
     */
    public void xsetSchemaOutType(org.apache.xmlbeans.XmlString schemaOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAOUTTYPE$24, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAOUTTYPE$24);
            }
            target.set(schemaOutType);
        }
    }
    
    /**
     * Unsets the "schemaOutType" element
     */
    public void unsetSchemaOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAOUTTYPE$24, 0);
        }
    }
    
    /**
     * Gets the "adaptorOut" element
     */
    public java.lang.String getAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUT$26, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorOut" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUT$26, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorOut" element
     */
    public boolean isSetAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTOROUT$26) != 0;
        }
    }
    
    /**
     * Sets the "adaptorOut" element
     */
    public void setAdaptorOut(java.lang.String adaptorOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUT$26, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTOROUT$26);
            }
            target.setStringValue(adaptorOut);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorOut" element
     */
    public void xsetAdaptorOut(org.apache.xmlbeans.XmlString adaptorOut)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUT$26, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTOROUT$26);
            }
            target.set(adaptorOut);
        }
    }
    
    /**
     * Unsets the "adaptorOut" element
     */
    public void unsetAdaptorOut()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTOROUT$26, 0);
        }
    }
    
    /**
     * Gets the "adaptorOutType" element
     */
    public java.lang.String getAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUTTYPE$28, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorOutType" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUTTYPE$28, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorOutType" element
     */
    public boolean isSetAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTOROUTTYPE$28) != 0;
        }
    }
    
    /**
     * Sets the "adaptorOutType" element
     */
    public void setAdaptorOutType(java.lang.String adaptorOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTOROUTTYPE$28, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTOROUTTYPE$28);
            }
            target.setStringValue(adaptorOutType);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorOutType" element
     */
    public void xsetAdaptorOutType(org.apache.xmlbeans.XmlString adaptorOutType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTOROUTTYPE$28, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTOROUTTYPE$28);
            }
            target.set(adaptorOutType);
        }
    }
    
    /**
     * Unsets the "adaptorOutType" element
     */
    public void unsetAdaptorOutType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTOROUTTYPE$28, 0);
        }
    }
    
    /**
     * Gets the "schemaIn" element
     */
    public java.lang.String getSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAIN$30, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaIn" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAIN$30, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaIn" element
     */
    public boolean isSetSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAIN$30) != 0;
        }
    }
    
    /**
     * Sets the "schemaIn" element
     */
    public void setSchemaIn(java.lang.String schemaIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAIN$30, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAIN$30);
            }
            target.setStringValue(schemaIn);
        }
    }
    
    /**
     * Sets (as xml) the "schemaIn" element
     */
    public void xsetSchemaIn(org.apache.xmlbeans.XmlString schemaIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAIN$30, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAIN$30);
            }
            target.set(schemaIn);
        }
    }
    
    /**
     * Unsets the "schemaIn" element
     */
    public void unsetSchemaIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAIN$30, 0);
        }
    }
    
    /**
     * Gets the "schemaInType" element
     */
    public java.lang.String getSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAINTYPE$32, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaInType" element
     */
    public org.apache.xmlbeans.XmlString xgetSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAINTYPE$32, 0);
            return target;
        }
    }
    
    /**
     * True if has "schemaInType" element
     */
    public boolean isSetSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SCHEMAINTYPE$32) != 0;
        }
    }
    
    /**
     * Sets the "schemaInType" element
     */
    public void setSchemaInType(java.lang.String schemaInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SCHEMAINTYPE$32, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SCHEMAINTYPE$32);
            }
            target.setStringValue(schemaInType);
        }
    }
    
    /**
     * Sets (as xml) the "schemaInType" element
     */
    public void xsetSchemaInType(org.apache.xmlbeans.XmlString schemaInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(SCHEMAINTYPE$32, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(SCHEMAINTYPE$32);
            }
            target.set(schemaInType);
        }
    }
    
    /**
     * Unsets the "schemaInType" element
     */
    public void unsetSchemaInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SCHEMAINTYPE$32, 0);
        }
    }
    
    /**
     * Gets the "adaptorIn" element
     */
    public java.lang.String getAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORIN$34, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorIn" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORIN$34, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorIn" element
     */
    public boolean isSetAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTORIN$34) != 0;
        }
    }
    
    /**
     * Sets the "adaptorIn" element
     */
    public void setAdaptorIn(java.lang.String adaptorIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORIN$34, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTORIN$34);
            }
            target.setStringValue(adaptorIn);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorIn" element
     */
    public void xsetAdaptorIn(org.apache.xmlbeans.XmlString adaptorIn)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORIN$34, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTORIN$34);
            }
            target.set(adaptorIn);
        }
    }
    
    /**
     * Unsets the "adaptorIn" element
     */
    public void unsetAdaptorIn()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTORIN$34, 0);
        }
    }
    
    /**
     * Gets the "adaptorInType" element
     */
    public java.lang.String getAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORINTYPE$36, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "adaptorInType" element
     */
    public org.apache.xmlbeans.XmlString xgetAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORINTYPE$36, 0);
            return target;
        }
    }
    
    /**
     * True if has "adaptorInType" element
     */
    public boolean isSetAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADAPTORINTYPE$36) != 0;
        }
    }
    
    /**
     * Sets the "adaptorInType" element
     */
    public void setAdaptorInType(java.lang.String adaptorInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ADAPTORINTYPE$36, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ADAPTORINTYPE$36);
            }
            target.setStringValue(adaptorInType);
        }
    }
    
    /**
     * Sets (as xml) the "adaptorInType" element
     */
    public void xsetAdaptorInType(org.apache.xmlbeans.XmlString adaptorInType)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(ADAPTORINTYPE$36, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(ADAPTORINTYPE$36);
            }
            target.set(adaptorInType);
        }
    }
    
    /**
     * Unsets the "adaptorInType" element
     */
    public void unsetAdaptorInType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADAPTORINTYPE$36, 0);
        }
    }
    
    /**
     * Gets array of all "keySchema" elements
     */
    public java.lang.String[] getKeySchemaArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(KEYSCHEMA$38, targetList);
            java.lang.String[] result = new java.lang.String[targetList.size()];
            for (int i = 0, len = targetList.size() ; i < len ; i++)
                result[i] = ((org.apache.xmlbeans.SimpleValue)targetList.get(i)).getStringValue();
            return result;
        }
    }
    
    /**
     * Gets ith "keySchema" element
     */
    public java.lang.String getKeySchemaArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(KEYSCHEMA$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) array of all "keySchema" elements
     */
    public org.apache.xmlbeans.XmlString[] xgetKeySchemaArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(KEYSCHEMA$38, targetList);
            org.apache.xmlbeans.XmlString[] result = new org.apache.xmlbeans.XmlString[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets (as xml) ith "keySchema" element
     */
    public org.apache.xmlbeans.XmlString xgetKeySchemaArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(KEYSCHEMA$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return (org.apache.xmlbeans.XmlString)target;
        }
    }
    
    /**
     * Returns number of "keySchema" element
     */
    public int sizeOfKeySchemaArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(KEYSCHEMA$38);
        }
    }
    
    /**
     * Sets array of all "keySchema" element
     */
    public void setKeySchemaArray(java.lang.String[] keySchemaArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(keySchemaArray, KEYSCHEMA$38);
        }
    }
    
    /**
     * Sets ith "keySchema" element
     */
    public void setKeySchemaArray(int i, java.lang.String keySchema)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(KEYSCHEMA$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.setStringValue(keySchema);
        }
    }
    
    /**
     * Sets (as xml) array of all "keySchema" element
     */
    public void xsetKeySchemaArray(org.apache.xmlbeans.XmlString[]keySchemaArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(keySchemaArray, KEYSCHEMA$38);
        }
    }
    
    /**
     * Sets (as xml) ith "keySchema" element
     */
    public void xsetKeySchemaArray(int i, org.apache.xmlbeans.XmlString keySchema)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(KEYSCHEMA$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(keySchema);
        }
    }
    
    /**
     * Inserts the value as the ith "keySchema" element
     */
    public void insertKeySchema(int i, java.lang.String keySchema)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = 
                (org.apache.xmlbeans.SimpleValue)get_store().insert_element_user(KEYSCHEMA$38, i);
            target.setStringValue(keySchema);
        }
    }
    
    /**
     * Appends the value as the last "keySchema" element
     */
    public void addKeySchema(java.lang.String keySchema)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(KEYSCHEMA$38);
            target.setStringValue(keySchema);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "keySchema" element
     */
    public org.apache.xmlbeans.XmlString insertNewKeySchema(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().insert_element_user(KEYSCHEMA$38, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "keySchema" element
     */
    public org.apache.xmlbeans.XmlString addNewKeySchema()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(KEYSCHEMA$38);
            return target;
        }
    }
    
    /**
     * Removes the ith "keySchema" element
     */
    public void removeKeySchema(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(KEYSCHEMA$38, i);
        }
    }
    
    /**
     * Gets array of all "command" elements
     */
    public com.seedwill.xul.core.XCommand[] getCommandArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(COMMAND$40, targetList);
            com.seedwill.xul.core.XCommand[] result = new com.seedwill.xul.core.XCommand[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "command" element
     */
    public com.seedwill.xul.core.XCommand getCommandArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XCommand target = null;
            target = (com.seedwill.xul.core.XCommand)get_store().find_element_user(COMMAND$40, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "command" element
     */
    public int sizeOfCommandArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COMMAND$40);
        }
    }
    
    /**
     * Sets array of all "command" element
     */
    public void setCommandArray(com.seedwill.xul.core.XCommand[] commandArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(commandArray, COMMAND$40);
        }
    }
    
    /**
     * Sets ith "command" element
     */
    public void setCommandArray(int i, com.seedwill.xul.core.XCommand command)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XCommand target = null;
            target = (com.seedwill.xul.core.XCommand)get_store().find_element_user(COMMAND$40, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(command);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "command" element
     */
    public com.seedwill.xul.core.XCommand insertNewCommand(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XCommand target = null;
            target = (com.seedwill.xul.core.XCommand)get_store().insert_element_user(COMMAND$40, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "command" element
     */
    public com.seedwill.xul.core.XCommand addNewCommand()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XCommand target = null;
            target = (com.seedwill.xul.core.XCommand)get_store().add_element_user(COMMAND$40);
            return target;
        }
    }
    
    /**
     * Removes the ith "command" element
     */
    public void removeCommand(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COMMAND$40, i);
        }
    }
    
    /**
     * Gets the "schemaId" attribute
     */
    public java.lang.String getSchemaId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SCHEMAID$42);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "schemaId" attribute
     */
    public org.apache.xmlbeans.XmlString xgetSchemaId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(SCHEMAID$42);
            return target;
        }
    }
    
    /**
     * True if has "schemaId" attribute
     */
    public boolean isSetSchemaId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(SCHEMAID$42) != null;
        }
    }
    
    /**
     * Sets the "schemaId" attribute
     */
    public void setSchemaId(java.lang.String schemaId)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SCHEMAID$42);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SCHEMAID$42);
            }
            target.setStringValue(schemaId);
        }
    }
    
    /**
     * Sets (as xml) the "schemaId" attribute
     */
    public void xsetSchemaId(org.apache.xmlbeans.XmlString schemaId)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(SCHEMAID$42);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(SCHEMAID$42);
            }
            target.set(schemaId);
        }
    }
    
    /**
     * Unsets the "schemaId" attribute
     */
    public void unsetSchemaId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(SCHEMAID$42);
        }
    }
}
